﻿using System;
using System.ComponentModel;
using System.Linq;
using System.Runtime.InteropServices;
using System.Net.NetworkInformation;
using System.Security.Principal;
using System.Security.Permissions;

namespace Citi.Helpers
{
    public class Impersonator : IDisposable
    {
        #region Public methods.
        // ------------------------------------------------------------------

        /// <summary>
        /// Constructor. Starts the impersonation with the given credentials.
        /// Please note that the account that instantiates the Impersonator class
        /// needs to have the 'Act as part of operating system' privilege set.
        /// </summary>
        /// <param name="userName">The name of the user to act as.</param>
        /// <param name="domainName">The domain name of the user to act as.</param>
        /// <param name="password">The password of the user to act as.</param>
        public Impersonator(string userName, string domainName, string password)
        {
            ImpersonateValidUser(userName, domainName, password);
        }

        // ------------------------------------------------------------------
        #endregion

        #region IDisposable member.
        // ------------------------------------------------------------------

        public void Dispose()
        {
            UndoImpersonation();
        }

        // ------------------------------------------------------------------
        #endregion

        #region P/Invoke.
        // ------------------------------------------------------------------

        [DllImport("advapi32.dll", SetLastError = true)]
        private static extern int LogonUser(string lpszUserName, string lpszDomain, string lpszPassword, int dwLogonType, int dwLogonProvider, ref IntPtr phToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern int DuplicateToken(IntPtr hToken, int impersonationLevel, ref IntPtr hNewToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool RevertToSelf();

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        private static extern bool CloseHandle(IntPtr handle);

        private const int LOGON32_LOGON_INTERACTIVE = 2;
        private const int LOGON32_PROVIDER_DEFAULT = 0;

        // ------------------------------------------------------------------
        #endregion

        #region Private member.
        // ------------------------------------------------------------------

        /// <summary>
        /// Does the actual impersonation.
        /// </summary>
        /// <param name="userName">The name of the user to act as.</param>
        /// <param name="domainName">The domain name of the user to act as.</param>
        /// <param name="password">The password of the user to act as.</param>
        private void ImpersonateValidUser(string userName, string domain, string password)
        {
            WindowsIdentity tempWindowsIdentity;
            IntPtr token = IntPtr.Zero;
            IntPtr tokenDuplicate = IntPtr.Zero;
            // request default security provider a logon token with LOGON32_LOGON_NEW_CREDENTIALS,
            // token returned is impersonation token, no need to duplicate
            if (LogonUser(userName, domain, password, 9, 0, ref token) != 0)
            {
                tempWindowsIdentity = new WindowsIdentity(token);
                impersonationContext = tempWindowsIdentity.Impersonate();
                // close impersonation token, no longer needed
                CloseHandle(token);
                if (impersonationContext != null)
                    return;
            }
            throw new Exception("Error");
        }

        //WindowsIdentity tempWindowsIdentity = null;
        //IntPtr token = IntPtr.Zero;
        //IntPtr tokenDuplicate = IntPtr.Zero;

        //try
        //{
        //    if (RevertToSelf())
        //    {
        //        if (LogonUser(userName, domain, password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref token) != 0)
        //        {
        //            if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
        //            {
        //                tempWindowsIdentity = new WindowsIdentity(tokenDuplicate);
        //                impersonationContext = tempWindowsIdentity.Impersonate();
        //            }
        //            else
        //                throw new Win32Exception(Marshal.GetLastWin32Error());
        //        }
        //        else
        //            throw new Win32Exception(Marshal.GetLastWin32Error());
        //    }
        //    else
        //        throw new Win32Exception(Marshal.GetLastWin32Error());
        //}
        //finally
        //{
        //    if (token != IntPtr.Zero)
        //        CloseHandle(token);
        //    if (tokenDuplicate != IntPtr.Zero)
        //        CloseHandle(tokenDuplicate);
        //}
        //}

        /// <summary>
        /// Reverts the impersonation.
        /// </summary>
        private void UndoImpersonation()
        {
            if (impersonationContext != null)
                impersonationContext.Undo();
        }

        private WindowsImpersonationContext impersonationContext = null;

        // ------------------------------------------------------------------
        #endregion
    }

    public class NetworkShareAccesser : IDisposable
    {
        //#region Consts
        //const int RESOURCE_CONNECTED = 0x00000001;
        //const int RESOURCE_GLOBALNET = 0x00000002;
        //const int RESOURCE_REMEMBERED = 0x00000003;

        //const int RESOURCETYPE_ANY = 0x00000000;
        //const int RESOURCETYPE_DISK = 0x00000001;
        //const int RESOURCETYPE_PRINT = 0x00000002;

        //const int RESOURCEDISPLAYTYPE_GENERIC = 0x00000000;
        //const int RESOURCEDISPLAYTYPE_DOMAIN = 0x00000001;
        //const int RESOURCEDISPLAYTYPE_SERVER = 0x00000002;
        //const int RESOURCEDISPLAYTYPE_SHARE = 0x00000003;
        //const int RESOURCEDISPLAYTYPE_FILE = 0x00000004;
        //const int RESOURCEDISPLAYTYPE_GROUP = 0x00000005;

        //const int RESOURCEUSAGE_CONNECTABLE = 0x00000001;
        //const int RESOURCEUSAGE_CONTAINER = 0x00000002;


        //const int CONNECT_INTERACTIVE = 0x00000008;
        //const int CONNECT_PROMPT = 0x00000010;
        //const int CONNECT_REDIRECT = 0x00000080;
        //const int CONNECT_UPDATE_PROFILE = 0x00000001;
        //const int CONNECT_COMMANDLINE = 0x00000800;
        //const int CONNECT_CMD_SAVECRED = 0x00001000;

        //const int CONNECT_LOCALDRIVE = 0x00000100;
        //#endregion

        //#region Errors
        //const int NO_ERROR = 0;

        //const int ERROR_ACCESS_DENIED = 5;
        //const int ERROR_ALREADY_ASSIGNED = 85;
        //const int ERROR_BAD_DEVICE = 1200;
        //const int ERROR_BAD_NET_NAME = 67;
        //const int ERROR_BAD_PROVIDER = 1204;
        //const int ERROR_CANCELLED = 1223;
        //const int ERROR_EXTENDED_ERROR = 1208;
        //const int ERROR_INVALID_ADDRESS = 487;
        //const int ERROR_INVALID_PARAMETER = 87;
        //const int ERROR_INVALID_PASSWORD = 1216;
        //const int ERROR_MORE_DATA = 234;
        //const int ERROR_NO_MORE_ITEMS = 259;
        //const int ERROR_NO_NET_OR_BAD_PATH = 1203;
        //const int ERROR_NO_NETWORK = 1222;

        //const int ERROR_BAD_PROFILE = 1206;
        //const int ERROR_CANNOT_OPEN_PROFILE = 1205;
        //const int ERROR_DEVICE_IN_USE = 2404;
        //const int ERROR_NOT_CONNECTED = 2250;
        //const int ERROR_OPEN_FILES = 2401;

        //private struct ErrorClass
        //{
        //    public int num;
        //    public string message;
        //    public ErrorClass(int num, string message)
        //    {
        //        this.num = num;
        //        this.message = message;
        //    }
        //}


        //// Created with excel formula:
        //// ="new ErrorClass("&A1&", """&PROPER(SUBSTITUTE(MID(A1,7,LEN(A1)-6), "_", " "))&"""), "
        //private static ErrorClass[] ERROR_LIST = new ErrorClass[] {
        //    new ErrorClass(ERROR_ACCESS_DENIED, "Error: Access Denied"), 
        //    new ErrorClass(ERROR_ALREADY_ASSIGNED, "Error: Already Assigned"), 
        //    new ErrorClass(ERROR_BAD_DEVICE, "Error: Bad Device"), 
        //    new ErrorClass(ERROR_BAD_NET_NAME, "Error: Bad Net Name"), 
        //    new ErrorClass(ERROR_BAD_PROVIDER, "Error: Bad Provider"), 
        //    new ErrorClass(ERROR_CANCELLED, "Error: Cancelled"), 
        //    new ErrorClass(ERROR_EXTENDED_ERROR, "Error: Extended Error"), 
        //    new ErrorClass(ERROR_INVALID_ADDRESS, "Error: Invalid Address"), 
        //    new ErrorClass(ERROR_INVALID_PARAMETER, "Error: Invalid Parameter"), 
        //    new ErrorClass(ERROR_INVALID_PASSWORD, "Error: Invalid Password"), 
        //    new ErrorClass(ERROR_MORE_DATA, "Error: More Data"), 
        //    new ErrorClass(ERROR_NO_MORE_ITEMS, "Error: No More Items"), 
        //    new ErrorClass(ERROR_NO_NET_OR_BAD_PATH, "Error: No Net Or Bad Path"), 
        //    new ErrorClass(ERROR_NO_NETWORK, "Error: No Network"), 
        //    new ErrorClass(ERROR_BAD_PROFILE, "Error: Bad Profile"), 
        //    new ErrorClass(ERROR_CANNOT_OPEN_PROFILE, "Error: Cannot Open Profile"), 
        //    new ErrorClass(ERROR_DEVICE_IN_USE, "Error: Device In Use"), 
        //    new ErrorClass(ERROR_EXTENDED_ERROR, "Error: Extended Error"), 
        //    new ErrorClass(ERROR_NOT_CONNECTED, "Error: Not Connected"), 
        //    new ErrorClass(ERROR_OPEN_FILES, "Error: Open Files"), 
        //};

        //private static string getErrorForNumber(int errNum)
        //{
        //    foreach (ErrorClass er in ERROR_LIST)
        //    {
        //        if (er.num == errNum) return er.message;
        //    }
        //    return "Error: Unknown, " + errNum;
        //}
        //#endregion

        //static string RemoteUncName;

        //[DllImport("Mpr.dll")]
        //private static extern int WNetUseConnection(
        //    IntPtr hwndOwner,
        //    NETRESOURCE lpNetResource,
        //    string lpPassword,
        //    string lpUserID,
        //    int dwFlags,
        //    string lpAccessName,
        //    string lpBufferSize,
        //    string lpResult
        //    );

        //[DllImport("Mpr.dll")]
        //private static extern int WNetCancelConnection2(
        //    string lpName,
        //    int dwFlags,
        //    bool fForce
        //    );

        //[StructLayout(LayoutKind.Sequential)]
        //private class NETRESOURCE
        //{
        //    public int dwScope = 0;
        //    public int dwType = 0;
        //    public int dwDisplayType = 0;
        //    public int dwUsage = 0;
        //    public string lpLocalName = "";
        //    public string lpRemoteName = "";
        //    public string lpComment = "";
        //    public string lpProvider = "";
        //}

        //public static NetworkShareAccesser Access(string remoteComputerName, string domainOrComuterName, string userName, string password)
        //{
        //    return new NetworkShareAccesser(remoteComputerName,
        //                                    domainOrComuterName + @"\" + userName,
        //                                    password);
        //}

        ///// <summary>
        ///// Creates a NetworkShareAccesser for the given computer name using the given username (format: domainOrComputername\Username) and password
        ///// </summary>
        ///// <param name="remoteComputerName"></param>
        ///// <param name="userName"></param>
        ///// <param name="password"></param>
        //public static NetworkShareAccesser Access(string remoteComputerName, string userName, string password)
        //{
        //    return new NetworkShareAccesser(remoteComputerName,
        //                                    userName,
        //                                    password);
        //}

        //public NetworkShareAccesser(string remoteComputerName, string username, string password, bool promptUser = false)
        //{
        //    if (remoteComputerName.Contains(":") || remoteComputerName.IsNullOrEmpty() || WindowsUtil.GetStatus(remoteComputerName) != IPStatus.Success)
        //        return;

        //    remoteComputerName = RemoteUncName = remoteComputerName.Split(new[] { "/", @"\\", @"\" }, StringSplitOptions.RemoveEmptyEntries).First();

        //    NETRESOURCE nr = new NETRESOURCE();
        //    nr.dwType = RESOURCETYPE_DISK;
        //    nr.lpRemoteName = remoteComputerName;
        //    //			nr.lpLocalName = "F:";

        //    int ret;
        //    if (promptUser)
        //        ret = WNetUseConnection(IntPtr.Zero, nr, "", "", CONNECT_INTERACTIVE | CONNECT_PROMPT, null, null, null);
        //    else
        //        ret = WNetUseConnection(IntPtr.Zero, nr, password, username, 0, null, null, null);

        //    if (ret != NO_ERROR)
        //    {
        //        var error = getErrorForNumber(ret);
        //        return;
        //    }
        //}

        //public static string DisconnectRemote(string remoteUNC)
        //{
        //    int ret = WNetCancelConnection2(remoteUNC, CONNECT_UPDATE_PROFILE, false);
        //    if (ret == NO_ERROR) return null;
        //    return getErrorForNumber(ret);
        //}

        //public void Dispose()
        //{
        //    if (RemoteUncName == null)
        //        return;

        //    DisconnectRemote(RemoteUncName);
        //}






        private string remoteUncName;
        private string remoteComputerName;

        public string RemoteComputerName
        {
            get
            {
                return remoteComputerName;
            }
            set
            {
                remoteComputerName = value;
                remoteUncName = @"\\" + remoteComputerName;
            }
        }

        public string UserName
        {
            get;
            set;
        }
        public string Password
        {
            get;
            set;
        }

        #region Consts

        private const int RESOURCE_CONNECTED = 0x00000001;
        private const int RESOURCE_GLOBALNET = 0x00000002;
        private const int RESOURCE_REMEMBERED = 0x00000003;

        private const int RESOURCETYPE_ANY = 0x00000000;
        private const int RESOURCETYPE_DISK = 0x00000001;
        private const int RESOURCETYPE_PRINT = 0x00000002;

        private const int RESOURCEDISPLAYTYPE_GENERIC = 0x00000000;
        private const int RESOURCEDISPLAYTYPE_DOMAIN = 0x00000001;
        private const int RESOURCEDISPLAYTYPE_SERVER = 0x00000002;
        private const int RESOURCEDISPLAYTYPE_SHARE = 0x00000003;
        private const int RESOURCEDISPLAYTYPE_FILE = 0x00000004;
        private const int RESOURCEDISPLAYTYPE_GROUP = 0x00000005;

        private const int RESOURCEUSAGE_CONNECTABLE = 0x00000001;
        private const int RESOURCEUSAGE_CONTAINER = 0x00000002;


        private const int CONNECT_INTERACTIVE = 0x00000008;
        private const int CONNECT_PROMPT = 0x00000010;
        private const int CONNECT_REDIRECT = 0x00000080;
        private const int CONNECT_UPDATE_PROFILE = 0x00000001;
        private const int CONNECT_COMMANDLINE = 0x00000800;
        private const int CONNECT_CMD_SAVECRED = 0x00001000;

        private const int CONNECT_LOCALDRIVE = 0x00000100;

        #endregion

        #region Errors

        private const int NO_ERROR = 0;

        private const int ERROR_ACCESS_DENIED = 5;
        private const int ERROR_ALREADY_ASSIGNED = 85;
        private const int ERROR_BAD_DEVICE = 1200;
        private const int ERROR_BAD_NET_NAME = 67;
        private const int ERROR_BAD_PROVIDER = 1204;
        private const int ERROR_CANCELLED = 1223;
        private const int ERROR_EXTENDED_ERROR = 1208;
        private const int ERROR_INVALID_ADDRESS = 487;
        private const int ERROR_INVALID_PARAMETER = 87;
        private const int ERROR_INVALID_PASSWORD = 1216;
        private const int ERROR_MORE_DATA = 234;
        private const int ERROR_NO_MORE_ITEMS = 259;
        private const int ERROR_NO_NET_OR_BAD_PATH = 1203;
        private const int ERROR_NO_NETWORK = 1222;

        private const int ERROR_BAD_PROFILE = 1206;
        private const int ERROR_CANNOT_OPEN_PROFILE = 1205;
        private const int ERROR_DEVICE_IN_USE = 2404;
        private const int ERROR_NOT_CONNECTED = 2250;
        private const int ERROR_OPEN_FILES = 2401;

        #endregion

        #region PInvoke Signatures

        [DllImport("Mpr.dll")]
        private static extern int WNetUseConnection(
            IntPtr hwndOwner,
            NETRESOURCE lpNetResource,
            string lpPassword,
            string lpUserID,
            int dwFlags,
            string lpAccessName,
            string lpBufferSize,
            string lpResult
            );

        [DllImport("Mpr.dll")]
        private static extern int WNetCancelConnection2(
            string lpName,
            int dwFlags,
            bool fForce
            );

        [StructLayout(LayoutKind.Sequential)]
        private class NETRESOURCE
        {
            public int dwScope = 0;
            public int dwType = 0;
            public int dwDisplayType = 0;
            public int dwUsage = 0;
            public string lpLocalName = "";
            public string lpRemoteName = "";
            public string lpComment = "";
            public string lpProvider = "";
        }

        #endregion

        /// <summary>
        /// Creates a NetworkShareAccesser for the given computer name. The user will be promted to enter credentials
        /// </summary>
        /// <param name="remoteComputerName"></param>
        /// <returns></returns>
        public static NetworkShareAccesser Access(string remoteComputerName)
        {
            return new NetworkShareAccesser(remoteComputerName);
        }

        /// <summary>
        /// Creates a NetworkShareAccesser for the given computer name using the given domain/computer name, username and password
        /// </summary>
        /// <param name="remoteComputerName"></param>
        /// <param name="domainOrComuterName"></param>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        public static NetworkShareAccesser Access(string remoteComputerName, string domainOrComuterName, string userName, string password)
        {
            return new NetworkShareAccesser(remoteComputerName,
                                            domainOrComuterName + @"\" + userName,
                                            password);
        }

        /// <summary>
        /// Creates a NetworkShareAccesser for the given computer name using the given username (format: domainOrComputername\Username) and password
        /// </summary>
        /// <param name="remoteComputerName"></param>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        public static NetworkShareAccesser Access(string remoteComputerName, string userName, string password)
        {
            return new NetworkShareAccesser(remoteComputerName,
                                            userName,
                                            password);
        }

        private NetworkShareAccesser(string remoteComputerName)
        {
            RemoteComputerName = remoteComputerName;

            ConnectToShare(this.remoteUncName, null, null, true);
        }

        private NetworkShareAccesser(string remoteComputerName, string userName, string password)
        {
            if (remoteComputerName.Contains(":") || remoteComputerName.IsNullOrEmpty())
                return;

            remoteComputerName = remoteComputerName.Split(new[] { "/", @"\\", @"\" }, StringSplitOptions.RemoveEmptyEntries).First();

            if (WindowsUtil.GetStatus(remoteComputerName) != IPStatus.Success)
                return;

            DisconnectFromShare(remoteComputerName);

            RemoteComputerName = remoteComputerName;
            UserName = userName;
            Password = password;

            this.ConnectToShare(this.remoteUncName, this.UserName, this.Password, false);
        }

        private void ConnectToShare(string remoteUnc, string username, string password, bool promptUser)
        {
            DisconnectFromShare(remoteUnc);

            NETRESOURCE nr = new NETRESOURCE
            {
                dwType = RESOURCETYPE_DISK,
                lpRemoteName = remoteUnc,
                dwDisplayType = 1,
                dwScope = 0,
                dwUsage = 0
            };

            int result;
            if (promptUser)
            {
                result = WNetUseConnection(IntPtr.Zero, nr, "", "", CONNECT_INTERACTIVE | CONNECT_PROMPT, null, null, null);
            }
            else
            {
                result = WNetUseConnection(IntPtr.Zero, nr, password, username, 0, null, null, null);
            }

            if (result != NO_ERROR)
            {
                Dispose();
                //throw new Win32Exception(result);
            }
        }

        private void DisconnectFromShare(string remoteUnc)
        {
            int result = WNetCancelConnection2(remoteUnc, CONNECT_UPDATE_PROFILE, false);
            if (result != NO_ERROR && result != ERROR_NOT_CONNECTED)
            {
                throw new Win32Exception(result);
            }
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        /// <filterpriority>2</filterpriority>
        public void Dispose()
        {
            if (remoteUncName == null)
                return;

            DisconnectFromShare(remoteUncName);
        }
    }
}
